{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 图像标题与RNNs\n",
    "在这个练习中，您将实现一个普通的递归神经网络，并使用它们来训练一个可以为图像生成新标题的模型。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T08:10:19.582246Z",
     "start_time": "2020-02-25T08:10:18.681617Z"
    }
   },
   "outputs": [],
   "source": [
    "# As usual, a bit of setup\n",
    "from __future__ import print_function\n",
    "import time, os, json\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from cs231n.gradient_check import eval_numerical_gradient, eval_numerical_gradient_array\n",
    "from cs231n.rnn_layers import *\n",
    "from cs231n.captioning_solver import CaptioningSolver\n",
    "from cs231n.classifiers.rnn import CaptioningRNN\n",
    "from cs231n.coco_utils import load_coco_data, sample_coco_minibatch, decode_captions\n",
    "from cs231n.image_utils import image_from_url\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "# for auto-reloading external modules\n",
    "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "def rel_error(x, y):\n",
    "    \"\"\" returns relative error \"\"\"\n",
    "    return np.max(np.abs(x - y) / (np.maximum(1e-8, np.abs(x) + np.abs(y))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 安装h5py\n",
    "我们将使用的COCO数据集以HDF5格式存储。要加载HDF5文件，我们需要安装' h5py ' Python包。从命令行运行:<br/>\n",
    "`pip install h5py`   <br/>\n",
    "如果您收到权限错误，您可能需要以根用户身份运行该命令:<br/>\n",
    "```sudo pip install h5py```\n",
    "你也可以直接从Jupyter笔记本上运行命令，方法是在命令前面加上“!”字符:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 微软COCO\n",
    "对于这个练习，我们将使用2014年发布的[Microsoft COCO数据集](http://mscoco.org/)，它已经成为图像字幕的标准测试平台。该数据集包括80,000张培训图像和40,000张验证图像，每个图像都有5个由Amazon Mechanical Turk上的工作人员编写的注释。\n",
    "通过切换到“cs231n/datasets”目录并运行脚本“get_assignment3_data.sh”，您应该已经下载了数据。如果您还没有这样做，现在就运行这个脚本。警告:可可数据下载是~1GB。\n",
    "我们已经对数据进行了预处理并为您提取了特征。对于所有的图像，我们提取了在ImageNet上预先训练的VGG-16网络的fc7层的特征;这些特性存储在文件的train2014_vgg16_fc7.h5’和‘val2014_vgg16_fc7.h5。为了减少处理时间和内存需求，我们将特征的维数从4096降至512;这些特性可以在train2014_vgg16_fc7_pca.h5’和‘val2014_vgg16_fc7_pca.h5”中找到。\n",
    "原始图像占用了大量空间(近20GB)，所以我们没有在下载中包含它们。但是，所有图像都是从Flickr获取的，培训和验证图像的url存储在文件的train2014_urls.txt”和“val2014_urls.txt。这允许您动态下载图像以实现可视化。由于图像是动态下载的，**您必须连接到互联网才能查看图像**。\n",
    "处理字符串的效率很低，所以我们将使用字幕的编码版本。每个单词都分配了一个整数ID，允许我们用一个整数序列来表示标题。整数id和单词之间的映射在文件“coco2014_vocab”中。可以使用文件cs231n/coco_utils中的函数decode_captions。将整数id的numpy数组转换回字符串。\n",
    "我们向词汇表中添加了一些特殊的标记。我们在每个标题的开头和结尾分别添加一个特殊的' <START> '令牌和' <END> '令牌。罕见的单词被替换为特殊的“<UNK>”令牌(表示“未知”)。此外，由于我们希望使用包含不同长度标题的小批量进行训练，所以我们在' <END> '标记之后用特殊的' <NULL> '标记填充短标题，并且不计算' <NULL> '标记的丢失或梯度。由于它们有点麻烦，我们已经为您处理了关于特殊令牌的所有实现细节。\n",
    "可以使用“cs231n/coco_utils.py”文件中的“load_coco_data”函数加载所有MS-COCO数据(标题、特性、url和词汇表)。运行以下单元格:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T08:10:20.164039Z",
     "start_time": "2020-02-25T08:10:19.582246Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train_captions <class 'numpy.ndarray'> (400135, 17) int32\n",
      "train_image_idxs <class 'numpy.ndarray'> (400135,) int32\n",
      "val_captions <class 'numpy.ndarray'> (195954, 17) int32\n",
      "val_image_idxs <class 'numpy.ndarray'> (195954,) int32\n",
      "train_features <class 'numpy.ndarray'> (82783, 512) float32\n",
      "val_features <class 'numpy.ndarray'> (40504, 512) float32\n",
      "idx_to_word <class 'list'> 1004\n",
      "word_to_idx <class 'dict'> 1004\n",
      "train_urls <class 'numpy.ndarray'> (82783,) <U63\n",
      "val_urls <class 'numpy.ndarray'> (40504,) <U63\n"
     ]
    }
   ],
   "source": [
    "# Load COCO data from disk; this returns a dictionary\n",
    "# We'll work with dimensionality-reduced features for this notebook, but feel\n",
    "# free to experiment with the original features by changing the flag below.\n",
    "data = load_coco_data(pca_features=True)\n",
    "\n",
    "# Print out all the keys and values from the data dictionary\n",
    "for k, v in data.items():\n",
    "    if type(v) == np.ndarray:\n",
    "        print(k, type(v), v.shape, v.dtype)\n",
    "    else:\n",
    "        print(k, type(v), len(v))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 看看数据\n",
    "在使用数据集之前，从数据集查看示例总是一个好主意。\n",
    "您可以使用文件“cs231n/coco_utils”中的“sample_coco_minibatch”函数。从load_coco_data返回的数据结构中提取少量数据。运行以下命令对一小批训练数据进行采样，并显示图像及其说明。多次运行它并查看结果可以帮助您了解数据集。\n",
    "请注意，我们使用' decode_captions '函数来解码字幕，我们使用Flickr URL动态下载图像，因此**您必须连接到互联网才能查看图像**。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T08:10:20.213786Z",
     "start_time": "2020-02-25T08:10:20.164039Z"
    }
   },
   "outputs": [],
   "source": [
    "# # Sample a minibatch and show the images and captions\n",
    "# batch_size = 3\n",
    "\n",
    "# captions, features, urls = sample_coco_minibatch(data, batch_size=batch_size)\n",
    "# for i, (caption, url) in enumerate(zip(captions, urls)):\n",
    "#     plt.imshow(image_from_url(url))\n",
    "#     plt.axis('off')\n",
    "#     caption_str = decode_captions(caption, data['idx_to_word'])\n",
    "#     plt.title(caption_str)\n",
    "#     plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 递归神经网络\n",
    "正如在课堂上所讨论的，我们将使用递归神经网络(RNN)语言模型进行图像字幕。文件的cs231n/rnn_layers.py '包含递归神经网络所需的不同层类型的实现，以及文件'cs231n/classifier/rnn.py'使用这些层来实现一个图像字幕模型。\n",
    "我们将首先在“cs231n/rnn_layers.py”中实现不同类型的RNN层。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Vanilla RNN:单步前向\n",
    "打开文件“cs231n/rnn_layers.py”。该文件实现了递归神经网络中常用的不同类型的层的向前和向后传递。\n",
    "首先实现函数“rnn_step_forward”，该函数实现普通递归神经网络单个时间步长的前向遍历。这样做之后，运行以下代码来检查您的实现。您应该看到错误小于1e-8。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T08:10:20.340018Z",
     "start_time": "2020-02-25T08:10:20.216778Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "next_h error:  6.292421426471037e-09\n"
     ]
    }
   ],
   "source": [
    "N, D, H = 3, 10, 4\n",
    "\n",
    "x = np.linspace(-0.4, 0.7, num=N*D).reshape(N, D)\n",
    "prev_h = np.linspace(-0.2, 0.5, num=N*H).reshape(N, H)\n",
    "Wx = np.linspace(-0.1, 0.9, num=D*H).reshape(D, H)\n",
    "Wh = np.linspace(-0.3, 0.7, num=H*H).reshape(H, H)\n",
    "b = np.linspace(-0.2, 0.4, num=H)\n",
    "\n",
    "next_h, _ = rnn_step_forward(x, prev_h, Wx, Wh, b)\n",
    "expected_next_h = np.asarray([\n",
    "  [-0.58172089, -0.50182032, -0.41232771, -0.31410098],\n",
    "  [ 0.66854692,  0.79562378,  0.87755553,  0.92795967],\n",
    "  [ 0.97934501,  0.99144213,  0.99646691,  0.99854353]])\n",
    "\n",
    "print('next_h error: ', rel_error(expected_next_h, next_h))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Vanilla RNN:单步后向\n",
    "在文件' cs231n/rnn_layers中。实现' rnn_step_back '函数。这样做之后，运行下面的代码来检查你的实现。您应该看到错误小于“1e-8”。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T08:10:20.415952Z",
     "start_time": "2020-02-25T08:10:20.340018Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dx error:  3.004984354606141e-10\n",
      "dprev_h error:  2.633205333189269e-10\n",
      "dWx error:  9.684083573724284e-10\n",
      "dWh error:  3.355162782632426e-10\n",
      "db error:  1.5956895526227225e-11\n"
     ]
    }
   ],
   "source": [
    "from cs231n.rnn_layers import rnn_step_forward, rnn_step_backward\n",
    "np.random.seed(231)\n",
    "N, D, H = 4, 5, 6\n",
    "x = np.random.randn(N, D)\n",
    "h = np.random.randn(N, H)\n",
    "Wx = np.random.randn(D, H)\n",
    "Wh = np.random.randn(H, H)\n",
    "b = np.random.randn(H)\n",
    "\n",
    "out, cache = rnn_step_forward(x, h, Wx, Wh, b)\n",
    "\n",
    "dnext_h = np.random.randn(*out.shape)\n",
    "\n",
    "fx = lambda x: rnn_step_forward(x, h, Wx, Wh, b)[0]\n",
    "fh = lambda prev_h: rnn_step_forward(x, h, Wx, Wh, b)[0]\n",
    "fWx = lambda Wx: rnn_step_forward(x, h, Wx, Wh, b)[0]\n",
    "fWh = lambda Wh: rnn_step_forward(x, h, Wx, Wh, b)[0]\n",
    "fb = lambda b: rnn_step_forward(x, h, Wx, Wh, b)[0]\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(fx, x, dnext_h)\n",
    "dprev_h_num = eval_numerical_gradient_array(fh, h, dnext_h)\n",
    "dWx_num = eval_numerical_gradient_array(fWx, Wx, dnext_h)\n",
    "dWh_num = eval_numerical_gradient_array(fWh, Wh, dnext_h)\n",
    "db_num = eval_numerical_gradient_array(fb, b, dnext_h)\n",
    "\n",
    "dx, dprev_h, dWx, dWh, db = rnn_step_backward(dnext_h, cache)\n",
    "\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "print('dprev_h error: ', rel_error(dprev_h_num, dprev_h))\n",
    "print('dWx error: ', rel_error(dWx_num, dWx))\n",
    "print('dWh error: ', rel_error(dWh_num, dWh))\n",
    "print('db error: ', rel_error(db_num, db))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Vanilla RNN:前向\n",
    "既然您已经实现了普通RNN的单个时间步长的向前和向后传递，那么您将组合这些片段来实现处理整个数据序列的RNN。\n",
    "在文件' cs231n/rnn_layers中。，实现函数rnn_forward。这应该使用上面定义的' rnn_step_forward '函数来实现。这样做之后，运行以下代码来检查您的实现。你应该看到错误小于' 1e-7 '。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T08:10:20.489469Z",
     "start_time": "2020-02-25T08:10:20.419275Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "h error:  7.728466180186066e-08\n"
     ]
    }
   ],
   "source": [
    "N, T, D, H = 2, 3, 4, 5\n",
    "\n",
    "x = np.linspace(-0.1, 0.3, num=N*T*D).reshape(N, T, D)\n",
    "h0 = np.linspace(-0.3, 0.1, num=N*H).reshape(N, H)\n",
    "Wx = np.linspace(-0.2, 0.4, num=D*H).reshape(D, H)\n",
    "Wh = np.linspace(-0.4, 0.1, num=H*H).reshape(H, H)\n",
    "b = np.linspace(-0.7, 0.1, num=H)\n",
    "\n",
    "h, _ = rnn_forward(x, h0, Wx, Wh, b)\n",
    "expected_h = np.asarray([\n",
    "  [\n",
    "    [-0.42070749, -0.27279261, -0.11074945,  0.05740409,  0.22236251],\n",
    "    [-0.39525808, -0.22554661, -0.0409454,   0.14649412,  0.32397316],\n",
    "    [-0.42305111, -0.24223728, -0.04287027,  0.15997045,  0.35014525],\n",
    "  ],\n",
    "  [\n",
    "    [-0.55857474, -0.39065825, -0.19198182,  0.02378408,  0.23735671],\n",
    "    [-0.27150199, -0.07088804,  0.13562939,  0.33099728,  0.50158768],\n",
    "    [-0.51014825, -0.30524429, -0.06755202,  0.17806392,  0.40333043]]])\n",
    "print('h error: ', rel_error(expected_h, h))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Vanilla RNN:后向\n",
    "在文件' cs231n/rnn_layers中。在函数“rnn_reverse”中实现普通RNN的向后传递。这应该在整个序列上运行反向传播，调用上面定义的' rnn_step_back '函数。你应该看到误差小于5e-7。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T08:10:20.594708Z",
     "start_time": "2020-02-25T08:10:20.493457Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dx error:  1.9817764131204256e-09\n",
      "dh0 error:  3.381247306333069e-09\n",
      "dWx error:  7.2584869558584315e-09\n",
      "dWh error:  1.2801162187950054e-07\n",
      "db error:  4.36726574107421e-10\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "\n",
    "N, D, T, H = 2, 3, 10, 5\n",
    "\n",
    "x = np.random.randn(N, T, D)\n",
    "h0 = np.random.randn(N, H)\n",
    "Wx = np.random.randn(D, H)\n",
    "Wh = np.random.randn(H, H)\n",
    "b = np.random.randn(H)\n",
    "\n",
    "out, cache = rnn_forward(x, h0, Wx, Wh, b)\n",
    "\n",
    "dout = np.random.randn(*out.shape)\n",
    "\n",
    "dx, dh0, dWx, dWh, db = rnn_backward(dout, cache)\n",
    "\n",
    "fx = lambda x: rnn_forward(x, h0, Wx, Wh, b)[0]\n",
    "fh0 = lambda h0: rnn_forward(x, h0, Wx, Wh, b)[0]\n",
    "fWx = lambda Wx: rnn_forward(x, h0, Wx, Wh, b)[0]\n",
    "fWh = lambda Wh: rnn_forward(x, h0, Wx, Wh, b)[0]\n",
    "fb = lambda b: rnn_forward(x, h0, Wx, Wh, b)[0]\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(fx, x, dout)\n",
    "dh0_num = eval_numerical_gradient_array(fh0, h0, dout)\n",
    "dWx_num = eval_numerical_gradient_array(fWx, Wx, dout)\n",
    "dWh_num = eval_numerical_gradient_array(fWh, Wh, dout)\n",
    "db_num = eval_numerical_gradient_array(fb, b, dout)\n",
    "\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "print('dh0 error: ', rel_error(dh0_num, dh0))\n",
    "print('dWx error: ', rel_error(dWx_num, dWx))\n",
    "print('dWh error: ', rel_error(dWh_num, dWh))\n",
    "print('db error: ', rel_error(db_num, db))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 文字嵌入:前向\n",
    "在深度学习系统中，我们通常使用向量来表示单词。词汇表中的每个单词都将与一个向量相关联，这些向量将与系统的其他部分共同学习。\n",
    "在文件' cs231n/rnn_layers‘中实现函数“word_embedding_forward”将单词(用整数表示)转换为向量。运行以下命令来检查您的实现。你应该看到误差在“1e-8”附近。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T08:10:20.653415Z",
     "start_time": "2020-02-25T08:10:20.594708Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "out error:  1.0000000094736443e-08\n"
     ]
    }
   ],
   "source": [
    "N, T, V, D = 2, 4, 5, 3\n",
    "\n",
    "x = np.asarray([[0, 3, 1, 2], [2, 1, 0, 3]])\n",
    "W = np.linspace(0, 1, num=V*D).reshape(V, D)\n",
    "\n",
    "out, _ = word_embedding_forward(x, W)\n",
    "expected_out = np.asarray([\n",
    " [[ 0.,          0.07142857,  0.14285714],\n",
    "  [ 0.64285714,  0.71428571,  0.78571429],\n",
    "  [ 0.21428571,  0.28571429,  0.35714286],\n",
    "  [ 0.42857143,  0.5,         0.57142857]],\n",
    " [[ 0.42857143,  0.5,         0.57142857],\n",
    "  [ 0.21428571,  0.28571429,  0.35714286],\n",
    "  [ 0.,          0.07142857,  0.14285714],\n",
    "  [ 0.64285714,  0.71428571,  0.78571429]]])\n",
    "\n",
    "print('out error: ', rel_error(expected_out, out))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 文字嵌入:向后\n",
    "在函数“word_embedding_back”中实现单词嵌入函数的向后传递。这样做之后，运行下面的代码来检查你的实现。您应该看到错误小于' 1e-11 '。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T08:10:20.715593Z",
     "start_time": "2020-02-25T08:10:20.656407Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dW error:  3.2774595693100364e-12\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "\n",
    "N, T, V, D = 50, 3, 5, 6\n",
    "x = np.random.randint(V, size=(N, T))\n",
    "W = np.random.randn(V, D)\n",
    "\n",
    "out, cache = word_embedding_forward(x, W)\n",
    "dout = np.random.randn(*out.shape)\n",
    "dW = word_embedding_backward(dout, cache)\n",
    "\n",
    "f = lambda W: word_embedding_forward(x, W)[0]\n",
    "dW_num = eval_numerical_gradient_array(f, W, dout)\n",
    "\n",
    "print('dW error: ', rel_error(dW, dW_num))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 时间仿射层\n",
    "在每一个时间步，我们使用仿射函数将RNN隐藏向量转换成词汇表中每个单词的得分。因为这与您在作业2中实现的仿射层非常相似，所以我们在文件“cs231n/rnn_layers.py”中的“temporal_affine_forward”和“temporal_affine_back”函数中为您提供了这个函数。运行以下命令来对实现执行数值梯度检查。您应该看到错误小于1e-9。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T08:10:20.780421Z",
     "start_time": "2020-02-25T08:10:20.718586Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dx error:  2.9215854231394017e-10\n",
      "dw error:  1.5772169135951167e-10\n",
      "db error:  3.252200556967514e-11\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "\n",
    "# Gradient check for temporal affine layer\n",
    "N, T, D, M = 2, 3, 4, 5\n",
    "x = np.random.randn(N, T, D)\n",
    "w = np.random.randn(D, M)\n",
    "b = np.random.randn(M)\n",
    "\n",
    "out, cache = temporal_affine_forward(x, w, b)\n",
    "\n",
    "dout = np.random.randn(*out.shape)\n",
    "\n",
    "fx = lambda x: temporal_affine_forward(x, w, b)[0]\n",
    "fw = lambda w: temporal_affine_forward(x, w, b)[0]\n",
    "fb = lambda b: temporal_affine_forward(x, w, b)[0]\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(fx, x, dout)\n",
    "dw_num = eval_numerical_gradient_array(fw, w, dout)\n",
    "db_num = eval_numerical_gradient_array(fb, b, dout)\n",
    "\n",
    "dx, dw, db = temporal_affine_backward(dout, cache)\n",
    "\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "print('dw error: ', rel_error(dw_num, dw))\n",
    "print('db error: ', rel_error(db_num, db))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 时间 Softmax loss\n",
    "在RNN语言模型中，每一步我们都会为词汇表中的每个单词生成一个分数。我们知道每一步的地面真实字，所以我们使用一个softmax损失函数来计算每一步的损失和梯度。我们把一段时间内的损失加起来，然后把它们平均到最小批量上。\n",
    "\n",
    "但是有一个问题:因为我们操作的是小批量，不同的标题可能有不同的长度，所以我们在每个标题的后面附加‘<NULL>’标记，这样它们的长度都是相同的。我们不希望这些“<NULL>”标记计入损失或梯度，所以除了分数和ground-truth标签外，我们的损失函数还接受一个“mask”数组，该数组告诉它分数的哪些元素计入损失。\n",
    "由于这与你在作业1中实现的softmax损失函数非常相似，我们为你实现了这个损失函数;查看文件“cs231n/rnn_layers.py”中的“temporal_softmax_loss”函数。\n",
    "运行以下单元格来检查损失并对函数执行数值梯度检查。你会看到dx小于1e-7的误差。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T08:10:21.006073Z",
     "start_time": "2020-02-25T08:10:20.782420Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.3027781774290146\n",
      "23.025985953127226\n",
      "2.2643611790293394\n",
      "dx error:  2.583585303524283e-08\n"
     ]
    }
   ],
   "source": [
    "# Sanity check for temporal softmax loss\n",
    "from cs231n.rnn_layers import temporal_softmax_loss\n",
    "\n",
    "N, T, V = 100, 1, 10\n",
    "\n",
    "def check_loss(N, T, V, p):\n",
    "    x = 0.001 * np.random.randn(N, T, V)\n",
    "    y = np.random.randint(V, size=(N, T))\n",
    "    mask = np.random.rand(N, T) <= p\n",
    "    print(temporal_softmax_loss(x, y, mask)[0])\n",
    "  \n",
    "check_loss(100, 1, 10, 1.0)   # Should be about 2.3\n",
    "check_loss(100, 10, 10, 1.0)  # Should be about 23\n",
    "check_loss(5000, 10, 10, 0.1) # Should be about 2.3\n",
    "\n",
    "# Gradient check for temporal softmax loss\n",
    "N, T, V = 7, 8, 9\n",
    "\n",
    "x = np.random.randn(N, T, V)\n",
    "y = np.random.randint(V, size=(N, T))\n",
    "mask = (np.random.rand(N, T) > 0.5)\n",
    "\n",
    "loss, dx = temporal_softmax_loss(x, y, mask, verbose=False)\n",
    "\n",
    "dx_num = eval_numerical_gradient(lambda x: temporal_softmax_loss(x, y, mask)[0], x, verbose=False)\n",
    "\n",
    "print('dx error: ', rel_error(dx, dx_num))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# RNN图像字幕\n",
    "现在您已经实现了必要的层，您可以将它们组合起来构建一个图像字幕模型。打开文件' cs231n/classifier /rnn 然后查看“CaptioningRNN”类。\n",
    "在' loss '函数中实现模型的前向和后向遍历。目前，你只需要实现的情况下' cell_type='rnn' ' vanialla RNNs;稍后将实现LSTM用例。这样做之后，用一个小测试用例运行下面的代码来检查你的前向通过;你应该看到误差小于' 1e-10 '。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T08:10:21.071896Z",
     "start_time": "2020-02-25T08:10:21.006073Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss:  9.832355910027388\n",
      "expected loss:  9.83235591003\n",
      "difference:  2.611244553918368e-12\n"
     ]
    }
   ],
   "source": [
    "N, D, W, H = 10, 20, 30, 40\n",
    "word_to_idx = {'<NULL>': 0, 'cat': 2, 'dog': 3}\n",
    "V = len(word_to_idx)\n",
    "T = 13\n",
    "\n",
    "model = CaptioningRNN(word_to_idx,\n",
    "          input_dim=D,\n",
    "          wordvec_dim=W,\n",
    "          hidden_dim=H,\n",
    "          cell_type='rnn',\n",
    "          dtype=np.float64)\n",
    "\n",
    "# Set all model parameters to fixed values\n",
    "for k, v in model.params.items():\n",
    "    model.params[k] = np.linspace(-1.4, 1.3, num=v.size).reshape(*v.shape)\n",
    "\n",
    "features = np.linspace(-1.5, 0.3, num=(N * D)).reshape(N, D)\n",
    "captions = (np.arange(N * T) % V).reshape(N, T)\n",
    "\n",
    "loss, grads = model.loss(features, captions)\n",
    "expected_loss = 9.83235591003\n",
    "\n",
    "print('loss: ', loss)\n",
    "print('expected loss: ', expected_loss)\n",
    "print('difference: ', abs(loss - expected_loss))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "运行以下单元格对“CaptioningRNN”类执行数值梯度检查;你应该在错误应该小于' 5e-6 '"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T08:10:21.242951Z",
     "start_time": "2020-02-25T08:10:21.073889Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "W_embed relative error: 2.331072e-09\n",
      "W_proj relative error: 9.974424e-09\n",
      "W_vocab relative error: 4.274378e-09\n",
      "Wh relative error: 5.954804e-09\n",
      "Wx relative error: 8.455229e-07\n",
      "b relative error: 8.001353e-10\n",
      "b_proj relative error: 6.260036e-09\n",
      "b_vocab relative error: 6.918525e-11\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "\n",
    "batch_size = 2\n",
    "timesteps = 3\n",
    "input_dim = 4\n",
    "wordvec_dim = 5\n",
    "hidden_dim = 6\n",
    "word_to_idx = {'<NULL>': 0, 'cat': 2, 'dog': 3}\n",
    "vocab_size = len(word_to_idx)\n",
    "\n",
    "captions = np.random.randint(vocab_size, size=(batch_size, timesteps))\n",
    "features = np.random.randn(batch_size, input_dim)\n",
    "\n",
    "model = CaptioningRNN(word_to_idx,\n",
    "          input_dim=input_dim,\n",
    "          wordvec_dim=wordvec_dim,\n",
    "          hidden_dim=hidden_dim,\n",
    "          cell_type='rnn',\n",
    "          dtype=np.float64,\n",
    "        )\n",
    "\n",
    "loss, grads = model.loss(features, captions)\n",
    "\n",
    "for param_name in sorted(grads):\n",
    "    f = lambda _: model.loss(features, captions)[0]\n",
    "    param_grad_num = eval_numerical_gradient(f, model.params[param_name], verbose=False, h=1e-6)\n",
    "    e = rel_error(param_grad_num, grads[param_name])\n",
    "    print('%s relative error: %e' % (param_name, e))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 小数据过拟合\n",
    "类似于我们在之前的作业中用来训练图像分类模型的“解码器”类，在这次作业中我们使用“字幕解码器”类来训练图像字幕模型。打开文件' cs231n/captioning_solver。然后通读“CaptioningSolver”类;看起来应该很眼熟。\n",
    "一旦您熟悉了API，运行以下代码以确保您的模型能够适应100个训练示例的小样本。您应该看到损失小于0.1。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T08:10:49.912388Z",
     "start_time": "2020-02-25T08:10:21.242951Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 100) loss: 76.913487\n",
      "(Iteration 11 / 100) loss: 21.063314\n",
      "(Iteration 21 / 100) loss: 4.016173\n",
      "(Iteration 31 / 100) loss: 0.567032\n",
      "(Iteration 41 / 100) loss: 0.239453\n",
      "(Iteration 51 / 100) loss: 0.162029\n",
      "(Iteration 61 / 100) loss: 0.111545\n",
      "(Iteration 71 / 100) loss: 0.097592\n",
      "(Iteration 81 / 100) loss: 0.099107\n",
      "(Iteration 91 / 100) loss: 0.073981\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "\n",
    "small_data = load_coco_data(max_train=50)\n",
    "\n",
    "small_rnn_model = CaptioningRNN(\n",
    "          cell_type='rnn',\n",
    "          word_to_idx=data['word_to_idx'],\n",
    "          input_dim=data['train_features'].shape[1],\n",
    "          hidden_dim=512,\n",
    "          wordvec_dim=256,\n",
    "        )\n",
    "\n",
    "small_rnn_solver = CaptioningSolver(small_rnn_model, small_data,\n",
    "           update_rule='adam',\n",
    "           num_epochs=50,\n",
    "           batch_size=25,\n",
    "           optim_config={\n",
    "             'learning_rate': 5e-3,\n",
    "           },\n",
    "           lr_decay=0.95,\n",
    "           verbose=True, print_every=10,\n",
    "         )\n",
    "\n",
    "small_rnn_solver.train()\n",
    "\n",
    "# Plot the training losses\n",
    "plt.plot(small_rnn_solver.loss_history)\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Loss')\n",
    "plt.title('Training loss history')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 测试时间取样\n",
    "与分类模型不同，图像字幕模型在训练时和测试时的表现非常不同。在训练时，我们可以访问ground-truth标题，因此我们在每一步都向RNN输入ground-truth单词。在测试时，我们在每个时间步上从词汇表上的分布抽样，并在下一个时间步上将抽样作为输入提供给RNN。\n",
    "在文件' cs231n/classifiers/rnn中。，实现用于测试时间抽样的“sample”方法。这样做之后，从您的过度拟合模型中对培训和验证数据运行以下示例。培训数据上的样本应该很好;验证数据上的示例可能没有意义。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T08:10:50.339375Z",
     "start_time": "2020-02-25T08:10:49.912388Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "http://farm5.staticflickr.com/4151/5003644046_1122a796c9_z.jpg\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "http://farm5.staticflickr.com/4134/4876982491_5359f44020_z.jpg\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "http://farm5.staticflickr.com/4086/5218606605_68fb694d6c_z.jpg\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "http://farm4.staticflickr.com/3019/2823442974_16c196c54c_z.jpg\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "for split in ['train', 'val']:\n",
    "    minibatch = sample_coco_minibatch(small_data, split=split, batch_size=2)\n",
    "    gt_captions, features, urls = minibatch\n",
    "    gt_captions = decode_captions(gt_captions, data['idx_to_word'])\n",
    "\n",
    "    sample_captions = small_rnn_model.sample(features)\n",
    "    sample_captions = decode_captions(sample_captions, data['idx_to_word'])\n",
    "\n",
    "    for gt_caption, sample_caption, url in zip(gt_captions, sample_captions, urls):\n",
    "#         plt.imshow(image_from_url(url))\n",
    "        print(url)\n",
    "        plt.title('%s\\n%s\\nGT:%s' % (split, sample_caption, gt_caption))\n",
    "        plt.axis('off')\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  },
  "nbTranslate": {
   "displayLangs": [
    "*"
   ],
   "hotkey": "alt-t",
   "langInMainMenu": true,
   "sourceLang": "en",
   "targetLang": "fr",
   "useGoogleTranslate": true
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
